home *** CD-ROM | disk | FTP | other *** search
/ Champak 141 / (Vol 141) Oct 17 2011.iso / Games / despereaux-swings.swf / scripts / Box2D / Collision / b2Collision.as < prev    next >
Encoding:
Text File  |  2011-10-17  |  25.4 KB  |  668 lines
  1. package Box2D.Collision
  2. {
  3.    import Box2D.Collision.Shapes.b2CircleShape;
  4.    import Box2D.Collision.Shapes.b2PolygonShape;
  5.    import Box2D.Common.Math.b2Mat22;
  6.    import Box2D.Common.Math.b2Math;
  7.    import Box2D.Common.Math.b2Vec2;
  8.    import Box2D.Common.Math.b2XForm;
  9.    import Box2D.Common.b2Settings;
  10.    
  11.    public class b2Collision
  12.    {
  13.       
  14.       public static const b2_nullFeature:uint = 255;
  15.       
  16.       private static var b2CollidePolyTempVec:b2Vec2 = new b2Vec2();
  17.        
  18.       
  19.       public function b2Collision()
  20.       {
  21.          super();
  22.       }
  23.       
  24.       public static function EdgeSeparation(param1:b2PolygonShape, param2:b2XForm, param3:int, param4:b2PolygonShape, param5:b2XForm) : Number
  25.       {
  26.          var _loc6_:int = 0;
  27.          var _loc7_:Array = null;
  28.          var _loc8_:Array = null;
  29.          var _loc9_:int = 0;
  30.          var _loc10_:Array = null;
  31.          var _loc11_:b2Mat22 = null;
  32.          var _loc12_:b2Vec2 = null;
  33.          var _loc13_:Number = NaN;
  34.          var _loc14_:Number = NaN;
  35.          var _loc15_:Number = NaN;
  36.          var _loc16_:Number = NaN;
  37.          var _loc17_:int = 0;
  38.          var _loc18_:Number = NaN;
  39.          var _loc19_:int = 0;
  40.          var _loc20_:Number = NaN;
  41.          var _loc21_:Number = NaN;
  42.          var _loc22_:Number = NaN;
  43.          var _loc23_:Number = NaN;
  44.          var _loc24_:Number = NaN;
  45.          var _loc25_:Number = NaN;
  46.          _loc6_ = param1.m_vertexCount;
  47.          _loc7_ = param1.m_vertices;
  48.          _loc8_ = param1.m_normals;
  49.          _loc9_ = param4.m_vertexCount;
  50.          _loc10_ = param4.m_vertices;
  51.          _loc11_ = param2.R;
  52.          _loc12_ = _loc8_[param3];
  53.          _loc13_ = _loc11_.col1.x * _loc12_.x + _loc11_.col2.x * _loc12_.y;
  54.          _loc14_ = _loc11_.col1.y * _loc12_.x + _loc11_.col2.y * _loc12_.y;
  55.          _loc15_ = (_loc11_ = param5.R).col1.x * _loc13_ + _loc11_.col1.y * _loc14_;
  56.          _loc16_ = _loc11_.col2.x * _loc13_ + _loc11_.col2.y * _loc14_;
  57.          _loc17_ = 0;
  58.          _loc18_ = Number.MAX_VALUE;
  59.          _loc19_ = 0;
  60.          while(_loc19_ < _loc9_)
  61.          {
  62.             if((_loc25_ = (_loc12_ = _loc10_[_loc19_]).x * _loc15_ + _loc12_.y * _loc16_) < _loc18_)
  63.             {
  64.                _loc18_ = _loc25_;
  65.                _loc17_ = _loc19_;
  66.             }
  67.             _loc19_++;
  68.          }
  69.          _loc12_ = _loc7_[param3];
  70.          _loc11_ = param2.R;
  71.          _loc20_ = param2.position.x + (_loc11_.col1.x * _loc12_.x + _loc11_.col2.x * _loc12_.y);
  72.          _loc21_ = param2.position.y + (_loc11_.col1.y * _loc12_.x + _loc11_.col2.y * _loc12_.y);
  73.          _loc12_ = _loc10_[_loc17_];
  74.          _loc11_ = param5.R;
  75.          _loc22_ = param5.position.x + (_loc11_.col1.x * _loc12_.x + _loc11_.col2.x * _loc12_.y);
  76.          _loc23_ = param5.position.y + (_loc11_.col1.y * _loc12_.x + _loc11_.col2.y * _loc12_.y);
  77.          _loc22_ -= _loc20_;
  78.          _loc23_ -= _loc21_;
  79.          return _loc22_ * _loc13_ + _loc23_ * _loc14_;
  80.       }
  81.       
  82.       public static function b2TestOverlap(param1:b2AABB, param2:b2AABB) : Boolean
  83.       {
  84.          var _loc3_:b2Vec2 = null;
  85.          var _loc4_:b2Vec2 = null;
  86.          var _loc5_:Number = NaN;
  87.          var _loc6_:Number = NaN;
  88.          var _loc7_:Number = NaN;
  89.          var _loc8_:Number = NaN;
  90.          _loc3_ = param2.lowerBound;
  91.          _loc4_ = param1.upperBound;
  92.          _loc5_ = _loc3_.x - _loc4_.x;
  93.          _loc6_ = _loc3_.y - _loc4_.y;
  94.          _loc3_ = param1.lowerBound;
  95.          _loc4_ = param2.upperBound;
  96.          _loc7_ = _loc3_.x - _loc4_.x;
  97.          _loc8_ = _loc3_.y - _loc4_.y;
  98.          if(_loc5_ > 0 || _loc6_ > 0)
  99.          {
  100.             return false;
  101.          }
  102.          if(_loc7_ > 0 || _loc8_ > 0)
  103.          {
  104.             return false;
  105.          }
  106.          return true;
  107.       }
  108.       
  109.       public static function FindIncidentEdge(param1:Array, param2:b2PolygonShape, param3:b2XForm, param4:int, param5:b2PolygonShape, param6:b2XForm) : void
  110.       {
  111.          var _loc7_:int = 0;
  112.          var _loc8_:Array = null;
  113.          var _loc9_:int = 0;
  114.          var _loc10_:Array = null;
  115.          var _loc11_:Array = null;
  116.          var _loc12_:b2Mat22 = null;
  117.          var _loc13_:b2Vec2 = null;
  118.          var _loc14_:Number = NaN;
  119.          var _loc15_:Number = NaN;
  120.          var _loc16_:Number = NaN;
  121.          var _loc17_:int = 0;
  122.          var _loc18_:Number = NaN;
  123.          var _loc19_:int = 0;
  124.          var _loc20_:ClipVertex = null;
  125.          var _loc21_:int = 0;
  126.          var _loc22_:int = 0;
  127.          var _loc23_:Number = NaN;
  128.          _loc7_ = param2.m_vertexCount;
  129.          _loc8_ = param2.m_normals;
  130.          _loc9_ = param5.m_vertexCount;
  131.          _loc10_ = param5.m_vertices;
  132.          _loc11_ = param5.m_normals;
  133.          _loc12_ = param3.R;
  134.          _loc13_ = _loc8_[param4];
  135.          _loc14_ = _loc12_.col1.x * _loc13_.x + _loc12_.col2.x * _loc13_.y;
  136.          _loc15_ = _loc12_.col1.y * _loc13_.x + _loc12_.col2.y * _loc13_.y;
  137.          _loc16_ = (_loc12_ = param6.R).col1.x * _loc14_ + _loc12_.col1.y * _loc15_;
  138.          _loc15_ = _loc12_.col2.x * _loc14_ + _loc12_.col2.y * _loc15_;
  139.          _loc14_ = _loc16_;
  140.          _loc17_ = 0;
  141.          _loc18_ = Number.MAX_VALUE;
  142.          _loc19_ = 0;
  143.          while(_loc19_ < _loc9_)
  144.          {
  145.             _loc13_ = _loc11_[_loc19_];
  146.             if((_loc23_ = _loc14_ * _loc13_.x + _loc15_ * _loc13_.y) < _loc18_)
  147.             {
  148.                _loc18_ = _loc23_;
  149.                _loc17_ = _loc19_;
  150.             }
  151.             _loc19_++;
  152.          }
  153.          _loc22_ = (_loc21_ = _loc17_) + 1 < _loc9_ ? _loc21_ + 1 : 0;
  154.          _loc20_ = param1[0];
  155.          _loc13_ = _loc10_[_loc21_];
  156.          _loc12_ = param6.R;
  157.          _loc20_.v.x = param6.position.x + (_loc12_.col1.x * _loc13_.x + _loc12_.col2.x * _loc13_.y);
  158.          _loc20_.v.y = param6.position.y + (_loc12_.col1.y * _loc13_.x + _loc12_.col2.y * _loc13_.y);
  159.          _loc20_.id.features.referenceEdge = param4;
  160.          _loc20_.id.features.incidentEdge = _loc21_;
  161.          _loc20_.id.features.incidentVertex = 0;
  162.          _loc20_ = param1[1];
  163.          _loc13_ = _loc10_[_loc22_];
  164.          _loc12_ = param6.R;
  165.          _loc20_.v.x = param6.position.x + (_loc12_.col1.x * _loc13_.x + _loc12_.col2.x * _loc13_.y);
  166.          _loc20_.v.y = param6.position.y + (_loc12_.col1.y * _loc13_.x + _loc12_.col2.y * _loc13_.y);
  167.          _loc20_.id.features.referenceEdge = param4;
  168.          _loc20_.id.features.incidentEdge = _loc22_;
  169.          _loc20_.id.features.incidentVertex = 1;
  170.       }
  171.       
  172.       public static function b2CollidePolygons(param1:b2Manifold, param2:b2PolygonShape, param3:b2XForm, param4:b2PolygonShape, param5:b2XForm) : void
  173.       {
  174.          var _loc6_:ClipVertex = null;
  175.          var _loc7_:int = 0;
  176.          var _loc8_:Array = null;
  177.          var _loc9_:Number = NaN;
  178.          var _loc10_:int = 0;
  179.          var _loc11_:Array = null;
  180.          var _loc12_:Number = NaN;
  181.          var _loc13_:b2PolygonShape = null;
  182.          var _loc14_:b2PolygonShape = null;
  183.          var _loc15_:b2XForm = null;
  184.          var _loc16_:b2XForm = null;
  185.          var _loc17_:int = 0;
  186.          var _loc18_:uint = 0;
  187.          var _loc19_:Number = NaN;
  188.          var _loc20_:Number = NaN;
  189.          var _loc21_:Array = null;
  190.          var _loc22_:int = 0;
  191.          var _loc23_:Array = null;
  192.          var _loc24_:b2Vec2 = null;
  193.          var _loc25_:b2Vec2 = null;
  194.          var _loc26_:b2Vec2 = null;
  195.          var _loc27_:b2Vec2 = null;
  196.          var _loc28_:b2Vec2 = null;
  197.          var _loc29_:Number = NaN;
  198.          var _loc30_:Number = NaN;
  199.          var _loc31_:Number = NaN;
  200.          var _loc32_:Array = null;
  201.          var _loc33_:Array = null;
  202.          var _loc34_:int = 0;
  203.          var _loc35_:int = 0;
  204.          var _loc36_:int = 0;
  205.          var _loc37_:b2Vec2 = null;
  206.          var _loc38_:Number = NaN;
  207.          var _loc39_:b2ManifoldPoint = null;
  208.          param1.pointCount = 0;
  209.          _loc8_ = [_loc7_ = 0];
  210.          _loc9_ = FindMaxSeparation(_loc8_,param2,param3,param4,param5);
  211.          _loc7_ = int(_loc8_[0]);
  212.          if(_loc9_ > 0)
  213.          {
  214.             return;
  215.          }
  216.          _loc11_ = [_loc10_ = 0];
  217.          _loc12_ = FindMaxSeparation(_loc11_,param4,param5,param2,param3);
  218.          _loc10_ = int(_loc11_[0]);
  219.          if(_loc12_ > 0)
  220.          {
  221.             return;
  222.          }
  223.          _loc15_ = new b2XForm();
  224.          _loc16_ = new b2XForm();
  225.          _loc19_ = 0.98;
  226.          _loc20_ = 0.001;
  227.          if(_loc12_ > _loc19_ * _loc9_ + _loc20_)
  228.          {
  229.             _loc13_ = param4;
  230.             _loc14_ = param2;
  231.             _loc15_.Set(param5);
  232.             _loc16_.Set(param3);
  233.             _loc17_ = _loc10_;
  234.             _loc18_ = 1;
  235.          }
  236.          else
  237.          {
  238.             _loc13_ = param2;
  239.             _loc14_ = param4;
  240.             _loc15_.Set(param3);
  241.             _loc16_.Set(param5);
  242.             _loc17_ = _loc7_;
  243.             _loc18_ = 0;
  244.          }
  245.          _loc21_ = [new ClipVertex(),new ClipVertex()];
  246.          FindIncidentEdge(_loc21_,_loc13_,_loc15_,_loc17_,_loc14_,_loc16_);
  247.          _loc22_ = _loc13_.m_vertexCount;
  248.          _loc25_ = (_loc24_ = (_loc23_ = _loc13_.m_vertices)[_loc17_]).Copy();
  249.          if(_loc17_ + 1 < _loc22_)
  250.          {
  251.             _loc37_ = (_loc24_ = _loc23_[int(_loc17_ + 1)]).Copy();
  252.          }
  253.          else
  254.          {
  255.             _loc37_ = (_loc24_ = _loc23_[0]).Copy();
  256.          }
  257.          _loc26_ = b2Math.SubtractVV(_loc37_,_loc25_);
  258.          (_loc27_ = b2Math.b2MulMV(_loc15_.R,b2Math.SubtractVV(_loc37_,_loc25_))).Normalize();
  259.          _loc28_ = b2Math.b2CrossVF(_loc27_,1);
  260.          _loc25_ = b2Math.b2MulX(_loc15_,_loc25_);
  261.          _loc37_ = b2Math.b2MulX(_loc15_,_loc37_);
  262.          _loc29_ = b2Math.b2Dot(_loc28_,_loc25_);
  263.          _loc30_ = -b2Math.b2Dot(_loc27_,_loc25_);
  264.          _loc31_ = b2Math.b2Dot(_loc27_,_loc37_);
  265.          _loc32_ = [new ClipVertex(),new ClipVertex()];
  266.          _loc33_ = [new ClipVertex(),new ClipVertex()];
  267.          if((_loc34_ = ClipSegmentToLine(_loc32_,_loc21_,_loc27_.Negative(),_loc30_)) < 2)
  268.          {
  269.             return;
  270.          }
  271.          if((_loc34_ = ClipSegmentToLine(_loc33_,_loc32_,_loc27_,_loc31_)) < 2)
  272.          {
  273.             return;
  274.          }
  275.          param1.normal = !!_loc18_ ? _loc28_.Negative() : _loc28_.Copy();
  276.          _loc35_ = 0;
  277.          _loc36_ = 0;
  278.          while(_loc36_ < b2Settings.b2_maxManifoldPoints)
  279.          {
  280.             _loc6_ = _loc33_[_loc36_];
  281.             if((_loc38_ = b2Math.b2Dot(_loc28_,_loc6_.v) - _loc29_) <= 0)
  282.             {
  283.                (_loc39_ = param1.points[_loc35_]).separation = _loc38_;
  284.                _loc39_.localPoint1 = b2Math.b2MulXT(param3,_loc6_.v);
  285.                _loc39_.localPoint2 = b2Math.b2MulXT(param5,_loc6_.v);
  286.                _loc39_.id.key = _loc6_.id._key;
  287.                _loc39_.id.features.flip = _loc18_;
  288.                _loc35_++;
  289.             }
  290.             _loc36_++;
  291.          }
  292.          param1.pointCount = _loc35_;
  293.       }
  294.       
  295.       public static function FindMaxSeparation(param1:Array, param2:b2PolygonShape, param3:b2XForm, param4:b2PolygonShape, param5:b2XForm) : Number
  296.       {
  297.          var _loc6_:int = 0;
  298.          var _loc7_:Array = null;
  299.          var _loc8_:b2Vec2 = null;
  300.          var _loc9_:b2Mat22 = null;
  301.          var _loc10_:Number = NaN;
  302.          var _loc11_:Number = NaN;
  303.          var _loc12_:Number = NaN;
  304.          var _loc13_:Number = NaN;
  305.          var _loc14_:int = 0;
  306.          var _loc15_:Number = NaN;
  307.          var _loc16_:int = 0;
  308.          var _loc17_:Number = NaN;
  309.          var _loc18_:int = 0;
  310.          var _loc19_:Number = NaN;
  311.          var _loc20_:int = 0;
  312.          var _loc21_:Number = NaN;
  313.          var _loc22_:int = 0;
  314.          var _loc23_:Number = NaN;
  315.          var _loc24_:int = 0;
  316.          var _loc25_:Number = NaN;
  317.          _loc6_ = param2.m_vertexCount;
  318.          _loc7_ = param2.m_normals;
  319.          _loc9_ = param5.R;
  320.          _loc8_ = param4.m_centroid;
  321.          _loc10_ = param5.position.x + (_loc9_.col1.x * _loc8_.x + _loc9_.col2.x * _loc8_.y);
  322.          _loc11_ = param5.position.y + (_loc9_.col1.y * _loc8_.x + _loc9_.col2.y * _loc8_.y);
  323.          _loc9_ = param3.R;
  324.          _loc8_ = param2.m_centroid;
  325.          _loc10_ -= param3.position.x + (_loc9_.col1.x * _loc8_.x + _loc9_.col2.x * _loc8_.y);
  326.          _loc11_ -= param3.position.y + (_loc9_.col1.y * _loc8_.x + _loc9_.col2.y * _loc8_.y);
  327.          _loc12_ = _loc10_ * param3.R.col1.x + _loc11_ * param3.R.col1.y;
  328.          _loc13_ = _loc10_ * param3.R.col2.x + _loc11_ * param3.R.col2.y;
  329.          _loc14_ = 0;
  330.          _loc15_ = -Number.MAX_VALUE;
  331.          _loc16_ = 0;
  332.          while(_loc16_ < _loc6_)
  333.          {
  334.             if((_loc25_ = (_loc8_ = _loc7_[_loc16_]).x * _loc12_ + _loc8_.y * _loc13_) > _loc15_)
  335.             {
  336.                _loc15_ = _loc25_;
  337.                _loc14_ = _loc16_;
  338.             }
  339.             _loc16_++;
  340.          }
  341.          if((_loc17_ = EdgeSeparation(param2,param3,_loc14_,param4,param5)) > 0)
  342.          {
  343.             return _loc17_;
  344.          }
  345.          _loc18_ = _loc14_ - 1 >= 0 ? _loc14_ - 1 : _loc6_ - 1;
  346.          if((_loc19_ = EdgeSeparation(param2,param3,_loc18_,param4,param5)) > 0)
  347.          {
  348.             return _loc19_;
  349.          }
  350.          _loc20_ = _loc14_ + 1 < _loc6_ ? _loc14_ + 1 : 0;
  351.          if((_loc21_ = EdgeSeparation(param2,param3,_loc20_,param4,param5)) > 0)
  352.          {
  353.             return _loc21_;
  354.          }
  355.          if(_loc19_ > _loc17_ && _loc19_ > _loc21_)
  356.          {
  357.             _loc24_ = -1;
  358.             _loc22_ = _loc18_;
  359.             _loc23_ = _loc19_;
  360.          }
  361.          else
  362.          {
  363.             if(_loc21_ <= _loc17_)
  364.             {
  365.                param1[0] = _loc14_;
  366.                return _loc17_;
  367.             }
  368.             _loc24_ = 1;
  369.             _loc22_ = _loc20_;
  370.             _loc23_ = _loc21_;
  371.          }
  372.          while(true)
  373.          {
  374.             if(_loc24_ == -1)
  375.             {
  376.                _loc14_ = _loc22_ - 1 >= 0 ? _loc22_ - 1 : _loc6_ - 1;
  377.             }
  378.             else
  379.             {
  380.                _loc14_ = _loc22_ + 1 < _loc6_ ? _loc22_ + 1 : 0;
  381.             }
  382.             if((_loc17_ = EdgeSeparation(param2,param3,_loc14_,param4,param5)) > 0)
  383.             {
  384.                break;
  385.             }
  386.             if(_loc17_ <= _loc23_)
  387.             {
  388.                param1[0] = _loc22_;
  389.                return _loc23_;
  390.             }
  391.             _loc22_ = _loc14_;
  392.             _loc23_ = _loc17_;
  393.          }
  394.          return _loc17_;
  395.       }
  396.       
  397.       public static function ClipSegmentToLine(param1:Array, param2:Array, param3:b2Vec2, param4:Number) : int
  398.       {
  399.          var _loc5_:ClipVertex = null;
  400.          var _loc6_:int = 0;
  401.          var _loc7_:b2Vec2 = null;
  402.          var _loc8_:b2Vec2 = null;
  403.          var _loc9_:Number = NaN;
  404.          var _loc10_:Number = NaN;
  405.          var _loc11_:Number = NaN;
  406.          var _loc12_:b2Vec2 = null;
  407.          var _loc13_:ClipVertex = null;
  408.          _loc6_ = 0;
  409.          _loc7_ = (_loc5_ = param2[0]).v;
  410.          _loc8_ = (_loc5_ = param2[1]).v;
  411.          _loc9_ = b2Math.b2Dot(param3,_loc7_) - param4;
  412.          _loc10_ = b2Math.b2Dot(param3,_loc8_) - param4;
  413.          if(_loc9_ <= 0)
  414.          {
  415.             var _loc14_:*;
  416.             param1[_loc14_ = _loc6_++] = param2[0];
  417.          }
  418.          if(_loc10_ <= 0)
  419.          {
  420.             param1[_loc14_ = _loc6_++] = param2[1];
  421.          }
  422.          if(_loc9_ * _loc10_ < 0)
  423.          {
  424.             _loc11_ = _loc9_ / (_loc9_ - _loc10_);
  425.             (_loc12_ = (_loc5_ = param1[_loc6_]).v).x = _loc7_.x + _loc11_ * (_loc8_.x - _loc7_.x);
  426.             _loc12_.y = _loc7_.y + _loc11_ * (_loc8_.y - _loc7_.y);
  427.             _loc5_ = param1[_loc6_];
  428.             if(_loc9_ > 0)
  429.             {
  430.                _loc13_ = param2[0];
  431.                _loc5_.id = _loc13_.id;
  432.             }
  433.             else
  434.             {
  435.                _loc13_ = param2[1];
  436.                _loc5_.id = _loc13_.id;
  437.             }
  438.             _loc6_++;
  439.          }
  440.          return _loc6_;
  441.       }
  442.       
  443.       public static function b2CollideCircles(param1:b2Manifold, param2:b2CircleShape, param3:b2XForm, param4:b2CircleShape, param5:b2XForm) : void
  444.       {
  445.          var _loc6_:b2Mat22 = null;
  446.          var _loc7_:b2Vec2 = null;
  447.          var _loc8_:Number = NaN;
  448.          var _loc9_:Number = NaN;
  449.          var _loc10_:Number = NaN;
  450.          var _loc11_:Number = NaN;
  451.          var _loc12_:Number = NaN;
  452.          var _loc13_:Number = NaN;
  453.          var _loc14_:Number = NaN;
  454.          var _loc15_:Number = NaN;
  455.          var _loc16_:Number = NaN;
  456.          var _loc17_:Number = NaN;
  457.          var _loc18_:Number = NaN;
  458.          var _loc19_:b2ManifoldPoint = null;
  459.          var _loc20_:Number = NaN;
  460.          var _loc21_:Number = NaN;
  461.          var _loc22_:Number = NaN;
  462.          var _loc23_:Number = NaN;
  463.          var _loc24_:Number = NaN;
  464.          var _loc25_:Number = NaN;
  465.          param1.pointCount = 0;
  466.          _loc6_ = param3.R;
  467.          _loc7_ = param2.m_localPosition;
  468.          _loc8_ = param3.position.x + (_loc6_.col1.x * _loc7_.x + _loc6_.col2.x * _loc7_.y);
  469.          _loc9_ = param3.position.y + (_loc6_.col1.y * _loc7_.x + _loc6_.col2.y * _loc7_.y);
  470.          _loc6_ = param5.R;
  471.          _loc7_ = param4.m_localPosition;
  472.          _loc10_ = param5.position.x + (_loc6_.col1.x * _loc7_.x + _loc6_.col2.x * _loc7_.y);
  473.          _loc11_ = param5.position.y + (_loc6_.col1.y * _loc7_.x + _loc6_.col2.y * _loc7_.y);
  474.          _loc12_ = _loc10_ - _loc8_;
  475.          _loc13_ = _loc11_ - _loc9_;
  476.          _loc14_ = _loc12_ * _loc12_ + _loc13_ * _loc13_;
  477.          _loc15_ = param2.m_radius;
  478.          _loc16_ = param4.m_radius;
  479.          _loc17_ = _loc15_ + _loc16_;
  480.          if(_loc14_ > _loc17_ * _loc17_)
  481.          {
  482.             return;
  483.          }
  484.          if(_loc14_ < Number.MIN_VALUE)
  485.          {
  486.             _loc18_ = -_loc17_;
  487.             param1.normal.Set(0,1);
  488.          }
  489.          else
  490.          {
  491.             _loc18_ = (_loc24_ = Math.sqrt(_loc14_)) - _loc17_;
  492.             _loc25_ = 1 / _loc24_;
  493.             param1.normal.x = _loc25_ * _loc12_;
  494.             param1.normal.y = _loc25_ * _loc13_;
  495.          }
  496.          param1.pointCount = 1;
  497.          (_loc19_ = param1.points[0]).id.key = 0;
  498.          _loc19_.separation = _loc18_;
  499.          _loc8_ += _loc15_ * param1.normal.x;
  500.          _loc9_ += _loc15_ * param1.normal.y;
  501.          _loc10_ -= _loc16_ * param1.normal.x;
  502.          _loc11_ -= _loc16_ * param1.normal.y;
  503.          _loc20_ = 0.5 * (_loc8_ + _loc10_);
  504.          _loc21_ = 0.5 * (_loc9_ + _loc11_);
  505.          _loc22_ = _loc20_ - param3.position.x;
  506.          _loc23_ = _loc21_ - param3.position.y;
  507.          _loc19_.localPoint1.x = _loc22_ * param3.R.col1.x + _loc23_ * param3.R.col1.y;
  508.          _loc19_.localPoint1.y = _loc22_ * param3.R.col2.x + _loc23_ * param3.R.col2.y;
  509.          _loc22_ = _loc20_ - param5.position.x;
  510.          _loc23_ = _loc21_ - param5.position.y;
  511.          _loc19_.localPoint2.x = _loc22_ * param5.R.col1.x + _loc23_ * param5.R.col1.y;
  512.          _loc19_.localPoint2.y = _loc22_ * param5.R.col2.x + _loc23_ * param5.R.col2.y;
  513.       }
  514.       
  515.       public static function b2CollidePolygonAndCircle(param1:b2Manifold, param2:b2PolygonShape, param3:b2XForm, param4:b2CircleShape, param5:b2XForm) : void
  516.       {
  517.          var _loc6_:b2ManifoldPoint = null;
  518.          var _loc7_:Number = NaN;
  519.          var _loc8_:Number = NaN;
  520.          var _loc9_:Number = NaN;
  521.          var _loc10_:Number = NaN;
  522.          var _loc11_:b2Vec2 = null;
  523.          var _loc12_:b2Mat22 = null;
  524.          var _loc13_:Number = NaN;
  525.          var _loc14_:Number = NaN;
  526.          var _loc15_:Number = NaN;
  527.          var _loc16_:Number = NaN;
  528.          var _loc17_:Number = NaN;
  529.          var _loc18_:int = 0;
  530.          var _loc19_:Number = NaN;
  531.          var _loc20_:Number = NaN;
  532.          var _loc21_:int = 0;
  533.          var _loc22_:Array = null;
  534.          var _loc23_:Array = null;
  535.          var _loc24_:int = 0;
  536.          var _loc25_:int = 0;
  537.          var _loc26_:int = 0;
  538.          var _loc27_:b2Vec2 = null;
  539.          var _loc28_:Number = NaN;
  540.          var _loc29_:Number = NaN;
  541.          var _loc30_:Number = NaN;
  542.          var _loc31_:Number = NaN;
  543.          var _loc32_:Number = NaN;
  544.          var _loc33_:Number = NaN;
  545.          var _loc34_:Number = NaN;
  546.          param1.pointCount = 0;
  547.          _loc12_ = param5.R;
  548.          _loc11_ = param4.m_localPosition;
  549.          _loc13_ = param5.position.x + (_loc12_.col1.x * _loc11_.x + _loc12_.col2.x * _loc11_.y);
  550.          _loc14_ = param5.position.y + (_loc12_.col1.y * _loc11_.x + _loc12_.col2.y * _loc11_.y);
  551.          _loc7_ = _loc13_ - param3.position.x;
  552.          _loc8_ = _loc14_ - param3.position.y;
  553.          _loc12_ = param3.R;
  554.          _loc15_ = _loc7_ * _loc12_.col1.x + _loc8_ * _loc12_.col1.y;
  555.          _loc16_ = _loc7_ * _loc12_.col2.x + _loc8_ * _loc12_.col2.y;
  556.          _loc18_ = 0;
  557.          _loc19_ = -Number.MAX_VALUE;
  558.          _loc20_ = param4.m_radius;
  559.          _loc21_ = param2.m_vertexCount;
  560.          _loc22_ = param2.m_vertices;
  561.          _loc23_ = param2.m_normals;
  562.          _loc24_ = 0;
  563.          while(_loc24_ < _loc21_)
  564.          {
  565.             _loc11_ = _loc22_[_loc24_];
  566.             _loc7_ = _loc15_ - _loc11_.x;
  567.             _loc8_ = _loc16_ - _loc11_.y;
  568.             if((_loc34_ = (_loc11_ = _loc23_[_loc24_]).x * _loc7_ + _loc11_.y * _loc8_) > _loc20_)
  569.             {
  570.                return;
  571.             }
  572.             if(_loc34_ > _loc19_)
  573.             {
  574.                _loc19_ = _loc34_;
  575.                _loc18_ = _loc24_;
  576.             }
  577.             _loc24_++;
  578.          }
  579.          if(_loc19_ < Number.MIN_VALUE)
  580.          {
  581.             param1.pointCount = 1;
  582.             _loc11_ = _loc23_[_loc18_];
  583.             _loc12_ = param3.R;
  584.             param1.normal.x = _loc12_.col1.x * _loc11_.x + _loc12_.col2.x * _loc11_.y;
  585.             param1.normal.y = _loc12_.col1.y * _loc11_.x + _loc12_.col2.y * _loc11_.y;
  586.             (_loc6_ = param1.points[0]).id.features.incidentEdge = _loc18_;
  587.             _loc6_.id.features.incidentVertex = b2_nullFeature;
  588.             _loc6_.id.features.referenceEdge = 0;
  589.             _loc6_.id.features.flip = 0;
  590.             _loc9_ = _loc13_ - _loc20_ * param1.normal.x;
  591.             _loc10_ = _loc14_ - _loc20_ * param1.normal.y;
  592.             _loc7_ = _loc9_ - param3.position.x;
  593.             _loc8_ = _loc10_ - param3.position.y;
  594.             _loc12_ = param3.R;
  595.             _loc6_.localPoint1.x = _loc7_ * _loc12_.col1.x + _loc8_ * _loc12_.col1.y;
  596.             _loc6_.localPoint1.y = _loc7_ * _loc12_.col2.x + _loc8_ * _loc12_.col2.y;
  597.             _loc7_ = _loc9_ - param5.position.x;
  598.             _loc8_ = _loc10_ - param5.position.y;
  599.             _loc12_ = param5.R;
  600.             _loc6_.localPoint2.x = _loc7_ * _loc12_.col1.x + _loc8_ * _loc12_.col1.y;
  601.             _loc6_.localPoint2.y = _loc7_ * _loc12_.col2.x + _loc8_ * _loc12_.col2.y;
  602.             _loc6_.separation = _loc19_ - _loc20_;
  603.             return;
  604.          }
  605.          _loc26_ = (_loc25_ = _loc18_) + 1 < _loc21_ ? _loc25_ + 1 : 0;
  606.          _loc11_ = _loc22_[_loc25_];
  607.          _loc28_ = (_loc27_ = _loc22_[_loc26_]).x - _loc11_.x;
  608.          _loc29_ = _loc27_.y - _loc11_.y;
  609.          _loc30_ = Math.sqrt(_loc28_ * _loc28_ + _loc29_ * _loc29_);
  610.          _loc28_ /= _loc30_;
  611.          _loc29_ /= _loc30_;
  612.          _loc7_ = _loc15_ - _loc11_.x;
  613.          _loc8_ = _loc16_ - _loc11_.y;
  614.          _loc31_ = _loc7_ * _loc28_ + _loc8_ * _loc29_;
  615.          _loc6_ = param1.points[0];
  616.          if(_loc31_ <= 0)
  617.          {
  618.             _loc32_ = _loc11_.x;
  619.             _loc33_ = _loc11_.y;
  620.             _loc6_.id.features.incidentEdge = b2_nullFeature;
  621.             _loc6_.id.features.incidentVertex = _loc25_;
  622.          }
  623.          else if(_loc31_ >= _loc30_)
  624.          {
  625.             _loc32_ = _loc27_.x;
  626.             _loc33_ = _loc27_.y;
  627.             _loc6_.id.features.incidentEdge = b2_nullFeature;
  628.             _loc6_.id.features.incidentVertex = _loc26_;
  629.          }
  630.          else
  631.          {
  632.             _loc32_ = _loc28_ * _loc31_ + _loc11_.x;
  633.             _loc33_ = _loc29_ * _loc31_ + _loc11_.y;
  634.             _loc6_.id.features.incidentEdge = _loc18_;
  635.             _loc6_.id.features.incidentVertex = 0;
  636.          }
  637.          _loc7_ = _loc15_ - _loc32_;
  638.          _loc8_ = _loc16_ - _loc33_;
  639.          _loc17_ = Math.sqrt(_loc7_ * _loc7_ + _loc8_ * _loc8_);
  640.          _loc7_ /= _loc17_;
  641.          _loc8_ /= _loc17_;
  642.          if(_loc17_ > _loc20_)
  643.          {
  644.             return;
  645.          }
  646.          param1.pointCount = 1;
  647.          _loc12_ = param3.R;
  648.          param1.normal.x = _loc12_.col1.x * _loc7_ + _loc12_.col2.x * _loc8_;
  649.          param1.normal.y = _loc12_.col1.y * _loc7_ + _loc12_.col2.y * _loc8_;
  650.          _loc9_ = _loc13_ - _loc20_ * param1.normal.x;
  651.          _loc10_ = _loc14_ - _loc20_ * param1.normal.y;
  652.          _loc7_ = _loc9_ - param3.position.x;
  653.          _loc8_ = _loc10_ - param3.position.y;
  654.          _loc12_ = param3.R;
  655.          _loc6_.localPoint1.x = _loc7_ * _loc12_.col1.x + _loc8_ * _loc12_.col1.y;
  656.          _loc6_.localPoint1.y = _loc7_ * _loc12_.col2.x + _loc8_ * _loc12_.col2.y;
  657.          _loc7_ = _loc9_ - param5.position.x;
  658.          _loc8_ = _loc10_ - param5.position.y;
  659.          _loc12_ = param5.R;
  660.          _loc6_.localPoint2.x = _loc7_ * _loc12_.col1.x + _loc8_ * _loc12_.col1.y;
  661.          _loc6_.localPoint2.y = _loc7_ * _loc12_.col2.x + _loc8_ * _loc12_.col2.y;
  662.          _loc6_.separation = _loc17_ - _loc20_;
  663.          _loc6_.id.features.referenceEdge = 0;
  664.          _loc6_.id.features.flip = 0;
  665.       }
  666.    }
  667. }
  668.